home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / dskut / aspisrc.zip / MANGLE.C < prev    next >
C/C++ Source or Header  |  1992-01-26  |  5KB  |  227 lines
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include "tar.h"
  4.  
  5. #ifdef __STDC__
  6. #define VOIDSTAR void *
  7. #else
  8. #define VOIDSTAR char *
  9. #endif
  10. extern VOIDSTAR ck_malloc();
  11. extern VOIDSTAR init_buffer();
  12. extern char *quote_copy_string();
  13. extern char *get_buffer();
  14. extern char *index();
  15.  
  16. extern union record *start_header();
  17.  
  18. extern struct stat hstat;        /* Stat struct corresponding */
  19.  
  20. struct mangled {
  21.     struct mangled *next;
  22.     int type;
  23.     char mangled[NAMSIZ];
  24.     char *linked_to;
  25.     char normal[1];
  26. };
  27.  
  28.  
  29. /* Should use a hash table, etc. .  */
  30. struct mangled *first_mangle;
  31. int mangled_num = 0;
  32.  
  33. char *
  34. find_mangled (name)
  35. char *name;
  36. {
  37.     struct mangled *munge;
  38.  
  39.     for(munge=first_mangle;munge;munge=munge->next)
  40.         if(!strcmp(name,munge->normal))
  41.             return munge->mangled;
  42.     return 0;
  43. }
  44.  
  45.  
  46. #ifdef S_IFLNK
  47. void add_symlink_mangle(symlink, linkto, buffer)
  48. char *symlink;
  49. char *linkto;
  50. char *buffer;
  51. {
  52.     struct mangled *munge,*kludge;
  53.  
  54.     munge=(struct mangled *)ck_malloc(sizeof(struct mangled)+strlen(symlink)+strlen(linkto)+2);
  55.     if(!first_mangle)
  56.         first_mangle=munge;
  57.     else {
  58.         for(kludge=first_mangle;kludge->next;kludge=kludge->next)
  59.             ;
  60.         kludge->next=munge;
  61.     }
  62.     munge->type=1;
  63.     munge->next=0;
  64.     strcpy(munge->normal,symlink);
  65.     munge->linked_to=munge->normal+strlen(symlink)+1;
  66.     strcpy(munge->linked_to,linkto);
  67.     sprintf(munge->mangled,"@@MaNgLeD.%d",mangled_num++);
  68.     strncpy(buffer,munge->mangled,NAMSIZ);
  69. }
  70. #endif
  71.  
  72. void
  73. add_mangle (name, buffer)
  74. char *name;
  75. char *buffer;
  76. {
  77.     struct mangled *munge,*kludge;
  78.  
  79.     munge=(struct mangled *)ck_malloc(sizeof(struct mangled)+strlen(name));
  80.     if(!first_mangle)
  81.         first_mangle=munge;
  82.     else {
  83.         for(kludge=first_mangle;kludge->next;kludge=kludge->next)
  84.             ;
  85.         kludge->next=munge;
  86.     }
  87.     munge->next=0;
  88.     munge->type=0;
  89.     strcpy(munge->normal,name);
  90.     sprintf(munge->mangled,"@@MaNgLeD.%d",mangled_num++);
  91.     strncpy(buffer,munge->mangled,NAMSIZ);
  92. }
  93.  
  94. void
  95. write_mangled()
  96. {
  97.     struct mangled *munge;
  98.     struct stat hstat;
  99.     union record *header;
  100.     char *ptr1,*ptr2;
  101.     VOIDSTAR the_buffer;
  102.     int size;
  103.     int bufsize;
  104.  
  105.     if(!first_mangle)
  106.         return;
  107.     the_buffer=init_buffer();
  108.     for(munge=first_mangle,size=0;munge;munge=munge->next) {
  109.         ptr1=quote_copy_string(munge->normal);
  110.         if(!ptr1)
  111.             ptr1=munge->normal;
  112.         if(munge->type) {
  113.             add_buffer(the_buffer,"Symlink ",8);
  114.             add_buffer(the_buffer,ptr1,strlen(ptr1));
  115.             add_buffer(the_buffer," to ",4);
  116.             
  117.             if(ptr2=quote_copy_string(munge->linked_to)) {
  118.                 add_buffer(the_buffer,ptr2,strlen(ptr2));
  119.                 free(ptr2);
  120.             } else
  121.                 add_buffer(the_buffer,munge->linked_to,strlen(munge->linked_to));
  122.         } else {
  123.             add_buffer(the_buffer,"Rename ",7);
  124.             add_buffer(the_buffer,munge->mangled,strlen(munge->mangled));
  125.             add_buffer(the_buffer," to ",4);
  126.             add_buffer(the_buffer,ptr1,strlen(ptr1));
  127.         }
  128.         add_buffer(the_buffer,"\n",1);
  129.         if(ptr1!=munge->normal)
  130.             free(ptr1);
  131.     }
  132.  
  133.     bzero(&hstat,sizeof(struct stat));
  134.     hstat.st_atime=hstat.st_mtime=hstat.st_ctime=time(0);
  135.     ptr1=get_buffer(the_buffer);
  136.     hstat.st_size=strlen(ptr1);
  137.  
  138.     header=start_header("././@MaNgLeD_NaMeS",&hstat);
  139.     header->header.linkflag=LF_NAMES;
  140.     finish_header(header);
  141.     size=hstat.st_size;
  142.     header=findrec();
  143.     bufsize = endofrecs()->charptr - header->charptr;
  144.  
  145.     while(bufsize<size) {
  146.         bcopy(ptr1,header->charptr,bufsize);
  147.         ptr1+=bufsize;
  148.         size-=bufsize;
  149.         userec(header+(bufsize-1)/RECORDSIZE);
  150.         header=findrec();
  151.         bufsize = endofrecs()->charptr - header->charptr;
  152.     }
  153.     bcopy(ptr1,header->charptr,size);
  154.     bzero(header->charptr+size,bufsize-size);
  155.     userec(header+(size-1)/RECORDSIZE);
  156. }
  157.  
  158. void
  159. extract_mangle(head)
  160. union record *head;
  161. {
  162.     char *buf;
  163.     char *fromtape;
  164.     char *to;
  165.     char *ptr,*ptrend;
  166.     char *nam1,*nam1end;
  167.     int size;
  168.     int copied;
  169.  
  170.     size=hstat.st_size;
  171.     buf=to=ck_malloc(size+1);
  172.     buf[size]='\0';
  173.     while(size>0) {
  174.         fromtape=findrec()->charptr;
  175.         if(fromtape==0) {
  176.             msg("Unexpected EOF in mangled names!");
  177.             return;
  178.         }
  179.         copied=endofrecs()->charptr-fromtape;
  180.         if(copied>size)
  181.             copied=size;
  182.         bcopy(fromtape,to,copied);
  183.         to+=copied;
  184.         size-=copied;
  185.         userec((union record *)(fromtape+copied-1));
  186.     }
  187.     for(ptr=buf;*ptr;ptr=ptrend) {
  188.         ptrend=index(ptr,'\n');
  189.         *ptrend++='\0';
  190.  
  191.         if(!strncmp(ptr,"Rename ",7)) {
  192.             nam1=ptr+7;
  193.             nam1end=index(nam1,' ');
  194.             while(strncmp(nam1end," to ",4)) {
  195.                 nam1end++;
  196.                 nam1end=index(nam1end,' ');
  197.             }
  198.             *nam1end='\0';
  199.             if(ptrend[-2]=='/')
  200.                 ptrend[-2]='\0';
  201.             un_quote_string(nam1end+4);
  202.             if(rename(nam1,nam1end+4))
  203.                 msg_perror("Can't rename %s to %s",nam1,nam1end+4);
  204.             else if(f_verbose)
  205.                 msg("Renamed %s to %s",nam1,nam1end+4);
  206.         }
  207. #ifdef S_IFLNK
  208.         else if(!strncmp(ptr,"Symlink ",8)) {
  209.             nam1=ptr+8;
  210.             nam1end=index(nam1,' ');
  211.             while(strncmp(nam1end," to ",4)) {
  212.                 nam1end++;
  213.                 nam1end=index(nam1end,' ');
  214.             }
  215.             un_quote_string(nam1);
  216.             un_quote_string(nam1end+4);
  217.             if(symlink(nam1,nam1end+4) && (unlink(nam1end+4) || symlink(nam1,nam1end+4)))
  218.                 msg_perror("Can't symlink %s to %s",nam1,nam1end+4);
  219.             else if(f_verbose)
  220.                 msg("Symlinkd %s to %s",nam1,nam1end+4);
  221.         }
  222. #endif
  223.         else
  224.             msg("Unknown demangling command %s",ptr);
  225.     }
  226. }
  227.